using System;
using System.Text;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using AjaxControlToolkit;

namespace AjaxControlToolkit.Models.MSTest
{
	
    public partial class ComboBoxDesignerTests
    {


        
        [TestMethod]
        public void ComboBoxDesignerTests_Property_DataValueField_PropertyAssigned ()
        {
            var objectUnderTest = CreateObject();
            System.String expectedValue;
        
            
            try
            {
                expectedValue = null;
                objectUnderTest.DataValueField = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.DataValueField)) || expectedValue == objectUnderTest.DataValueField);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "";
                objectUnderTest.DataValueField = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.DataValueField)) || expectedValue == objectUnderTest.DataValueField);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1";
                objectUnderTest.DataValueField = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.DataValueField)) || expectedValue == objectUnderTest.DataValueField);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "x";
                objectUnderTest.DataValueField = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.DataValueField)) || expectedValue == objectUnderTest.DataValueField);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = ",";
                objectUnderTest.DataValueField = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.DataValueField)) || expectedValue == objectUnderTest.DataValueField);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "123";
                objectUnderTest.DataValueField = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.DataValueField)) || expectedValue == objectUnderTest.DataValueField);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "abc";
                objectUnderTest.DataValueField = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.DataValueField)) || expectedValue == objectUnderTest.DataValueField);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1,2,3";
                objectUnderTest.DataValueField = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.DataValueField)) || expectedValue == objectUnderTest.DataValueField);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a,b,c";
                objectUnderTest.DataValueField = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.DataValueField)) || expectedValue == objectUnderTest.DataValueField);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1;2;3";
                objectUnderTest.DataValueField = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.DataValueField)) || expectedValue == objectUnderTest.DataValueField);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a;b;c";
                objectUnderTest.DataValueField = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.DataValueField)) || expectedValue == objectUnderTest.DataValueField);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "http://test.com";
                objectUnderTest.DataValueField = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.DataValueField)) || expectedValue == objectUnderTest.DataValueField);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "test@test.com";
                objectUnderTest.DataValueField = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.DataValueField)) || expectedValue == objectUnderTest.DataValueField);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
        
        }    
        
        
        [TestMethod]
        public void ComboBoxDesignerTests_Property_DataTextField_PropertyAssigned ()
        {
            var objectUnderTest = CreateObject();
            System.String expectedValue;
        
            
            try
            {
                expectedValue = null;
                objectUnderTest.DataTextField = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.DataTextField)) || expectedValue == objectUnderTest.DataTextField);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "";
                objectUnderTest.DataTextField = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.DataTextField)) || expectedValue == objectUnderTest.DataTextField);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1";
                objectUnderTest.DataTextField = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.DataTextField)) || expectedValue == objectUnderTest.DataTextField);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "x";
                objectUnderTest.DataTextField = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.DataTextField)) || expectedValue == objectUnderTest.DataTextField);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = ",";
                objectUnderTest.DataTextField = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.DataTextField)) || expectedValue == objectUnderTest.DataTextField);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "123";
                objectUnderTest.DataTextField = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.DataTextField)) || expectedValue == objectUnderTest.DataTextField);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "abc";
                objectUnderTest.DataTextField = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.DataTextField)) || expectedValue == objectUnderTest.DataTextField);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1,2,3";
                objectUnderTest.DataTextField = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.DataTextField)) || expectedValue == objectUnderTest.DataTextField);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a,b,c";
                objectUnderTest.DataTextField = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.DataTextField)) || expectedValue == objectUnderTest.DataTextField);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1;2;3";
                objectUnderTest.DataTextField = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.DataTextField)) || expectedValue == objectUnderTest.DataTextField);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a;b;c";
                objectUnderTest.DataTextField = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.DataTextField)) || expectedValue == objectUnderTest.DataTextField);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "http://test.com";
                objectUnderTest.DataTextField = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.DataTextField)) || expectedValue == objectUnderTest.DataTextField);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "test@test.com";
                objectUnderTest.DataTextField = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.DataTextField)) || expectedValue == objectUnderTest.DataTextField);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
        
        }    
        
        
        [TestMethod]
        public void ComboBoxDesignerTests_Property_DataMember_PropertyAssigned ()
        {
            var objectUnderTest = CreateObject();
            System.String expectedValue;
        
            
            try
            {
                expectedValue = null;
                objectUnderTest.DataMember = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.DataMember)) || expectedValue == objectUnderTest.DataMember);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "";
                objectUnderTest.DataMember = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.DataMember)) || expectedValue == objectUnderTest.DataMember);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1";
                objectUnderTest.DataMember = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.DataMember)) || expectedValue == objectUnderTest.DataMember);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "x";
                objectUnderTest.DataMember = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.DataMember)) || expectedValue == objectUnderTest.DataMember);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = ",";
                objectUnderTest.DataMember = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.DataMember)) || expectedValue == objectUnderTest.DataMember);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "123";
                objectUnderTest.DataMember = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.DataMember)) || expectedValue == objectUnderTest.DataMember);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "abc";
                objectUnderTest.DataMember = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.DataMember)) || expectedValue == objectUnderTest.DataMember);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1,2,3";
                objectUnderTest.DataMember = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.DataMember)) || expectedValue == objectUnderTest.DataMember);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a,b,c";
                objectUnderTest.DataMember = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.DataMember)) || expectedValue == objectUnderTest.DataMember);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1;2;3";
                objectUnderTest.DataMember = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.DataMember)) || expectedValue == objectUnderTest.DataMember);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a;b;c";
                objectUnderTest.DataMember = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.DataMember)) || expectedValue == objectUnderTest.DataMember);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "http://test.com";
                objectUnderTest.DataMember = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.DataMember)) || expectedValue == objectUnderTest.DataMember);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "test@test.com";
                objectUnderTest.DataMember = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.DataMember)) || expectedValue == objectUnderTest.DataMember);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
        
        }    
        
        
        [TestMethod]
        public void ComboBoxDesignerTests_Property_DataSource_PropertyAssigned ()
        {
            var objectUnderTest = CreateObject();
            System.String expectedValue;
        
            
            try
            {
                expectedValue = null;
                objectUnderTest.DataSource = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.DataSource)) || expectedValue == objectUnderTest.DataSource);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "";
                objectUnderTest.DataSource = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.DataSource)) || expectedValue == objectUnderTest.DataSource);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1";
                objectUnderTest.DataSource = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.DataSource)) || expectedValue == objectUnderTest.DataSource);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "x";
                objectUnderTest.DataSource = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.DataSource)) || expectedValue == objectUnderTest.DataSource);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = ",";
                objectUnderTest.DataSource = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.DataSource)) || expectedValue == objectUnderTest.DataSource);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "123";
                objectUnderTest.DataSource = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.DataSource)) || expectedValue == objectUnderTest.DataSource);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "abc";
                objectUnderTest.DataSource = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.DataSource)) || expectedValue == objectUnderTest.DataSource);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1,2,3";
                objectUnderTest.DataSource = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.DataSource)) || expectedValue == objectUnderTest.DataSource);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a,b,c";
                objectUnderTest.DataSource = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.DataSource)) || expectedValue == objectUnderTest.DataSource);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1;2;3";
                objectUnderTest.DataSource = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.DataSource)) || expectedValue == objectUnderTest.DataSource);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a;b;c";
                objectUnderTest.DataSource = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.DataSource)) || expectedValue == objectUnderTest.DataSource);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "http://test.com";
                objectUnderTest.DataSource = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.DataSource)) || expectedValue == objectUnderTest.DataSource);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "test@test.com";
                objectUnderTest.DataSource = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.DataSource)) || expectedValue == objectUnderTest.DataSource);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
        
        }    
        
        
        [TestMethod]
        public void ComboBoxDesignerTests_Property_DataSourceID_PropertyAssigned ()
        {
            var objectUnderTest = CreateObject();
            System.String expectedValue;
        
            
            try
            {
                expectedValue = null;
                objectUnderTest.DataSourceID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.DataSourceID)) || expectedValue == objectUnderTest.DataSourceID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "";
                objectUnderTest.DataSourceID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.DataSourceID)) || expectedValue == objectUnderTest.DataSourceID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1";
                objectUnderTest.DataSourceID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.DataSourceID)) || expectedValue == objectUnderTest.DataSourceID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "x";
                objectUnderTest.DataSourceID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.DataSourceID)) || expectedValue == objectUnderTest.DataSourceID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = ",";
                objectUnderTest.DataSourceID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.DataSourceID)) || expectedValue == objectUnderTest.DataSourceID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "123";
                objectUnderTest.DataSourceID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.DataSourceID)) || expectedValue == objectUnderTest.DataSourceID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "abc";
                objectUnderTest.DataSourceID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.DataSourceID)) || expectedValue == objectUnderTest.DataSourceID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1,2,3";
                objectUnderTest.DataSourceID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.DataSourceID)) || expectedValue == objectUnderTest.DataSourceID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a,b,c";
                objectUnderTest.DataSourceID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.DataSourceID)) || expectedValue == objectUnderTest.DataSourceID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1;2;3";
                objectUnderTest.DataSourceID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.DataSourceID)) || expectedValue == objectUnderTest.DataSourceID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a;b;c";
                objectUnderTest.DataSourceID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.DataSourceID)) || expectedValue == objectUnderTest.DataSourceID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "http://test.com";
                objectUnderTest.DataSourceID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.DataSourceID)) || expectedValue == objectUnderTest.DataSourceID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "test@test.com";
                objectUnderTest.DataSourceID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.DataSourceID)) || expectedValue == objectUnderTest.DataSourceID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
        
        }    
        
        
        [TestMethod]
        public void ComboBoxDesignerTests_Property_ID_PropertyAssigned ()
        {
            var objectUnderTest = CreateObject();
            System.String expectedValue;
        
            
            try
            {
                expectedValue = null;
                objectUnderTest.ID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ID)) || expectedValue == objectUnderTest.ID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "";
                objectUnderTest.ID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ID)) || expectedValue == objectUnderTest.ID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1";
                objectUnderTest.ID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ID)) || expectedValue == objectUnderTest.ID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "x";
                objectUnderTest.ID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ID)) || expectedValue == objectUnderTest.ID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = ",";
                objectUnderTest.ID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ID)) || expectedValue == objectUnderTest.ID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "123";
                objectUnderTest.ID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ID)) || expectedValue == objectUnderTest.ID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "abc";
                objectUnderTest.ID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ID)) || expectedValue == objectUnderTest.ID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1,2,3";
                objectUnderTest.ID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ID)) || expectedValue == objectUnderTest.ID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a,b,c";
                objectUnderTest.ID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ID)) || expectedValue == objectUnderTest.ID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "1;2;3";
                objectUnderTest.ID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ID)) || expectedValue == objectUnderTest.ID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "a;b;c";
                objectUnderTest.ID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ID)) || expectedValue == objectUnderTest.ID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "http://test.com";
                objectUnderTest.ID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ID)) || expectedValue == objectUnderTest.ID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = "test@test.com";
                objectUnderTest.ID = expectedValue;
                Assert.IsTrue((string.IsNullOrEmpty(expectedValue) && string.IsNullOrEmpty(objectUnderTest.ID)) || expectedValue == objectUnderTest.ID);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
        
        }    
        
        
        [TestMethod]
        public void ComboBoxDesignerTests_Property_ViewControlCreated_PropertyAssigned ()
        {
            var objectUnderTest = CreateObject();
            System.Boolean expectedValue;
        
            
            try
            {
                expectedValue = true;
                objectUnderTest.ViewControlCreated = expectedValue;
                Assert.AreEqual(expectedValue, objectUnderTest.ViewControlCreated);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
            
            try
            {
                expectedValue = false;
                objectUnderTest.ViewControlCreated = expectedValue;
                Assert.AreEqual(expectedValue, objectUnderTest.ViewControlCreated);;
            }
            catch (ArgumentException)
            {
                //OK
                return;
            }
            
        
        }    
        
    }
}

